package org.aplombh.java.awcing.basic.struct.trie;

import java.util.Scanner;

/**
 * 在给定的 N 个整数 A1，A2……AN 中选出两个进行 xor（异或）运算，得到的结果最大是多少？
 *
 * 输入格式
 * 第一行输入一个整数 N。
 *
 * 第二行输入 N 个整数 A1～AN。
 *
 * 输出格式
 * 输出一个整数表示答案。
 *
 * 数据范围
 * 1≤N≤105,
 * 0≤Ai<231
 * 输入样例：
 * 3
 * 1 2 3
 * 输出样例：
 * 3
 */
public class TrieXOR_143 {
    public static void main(String[] args) {
        TrieXOR trieXOR = new TrieXOR();
        Scanner scanner = new Scanner(System.in);
        int[] a = new int[TrieXOR.N];
        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
            trieXOR.insert(a[i]);
        }
        int res = 0;
        for (int i = 0; i < n; i++) res = Math.max(res, trieXOR.query(a[i]));
        System.out.println(res);
    }
}

class TrieXOR {

    public static final int N = 100010;
    private final int[][] son;
    private int idx; // 未重复才会使idx++

    public TrieXOR() {
        son = new int[N][26];
    }

    void insert(int x) {
        // 从前开始遍历，先查看当前位置是否∃，如果∃就将指向下一个位置，如果当前位置不存在，就将该节点指向++idx的位置，p指向idx，从当前结点开始全部都是新节点
        int p = 0;
        // 从i=30的位置开始遍历，从前往后遍历
        for (int i = 30; ~i != 0; i--) {
            // 如果为0，说明是新节点
            if (son[p][x >> i & 1] == 0)
                son[p][x >> i & 1] = ++idx;
            // 否则，该节点已经访问过了
            p = idx;
        }
    }
    int query(int x) {
        int res = 0, p = 0;


        for (int i = 30; ~i != 0; i--) {
            // s为当前位置的值
            int s = x >> i & 1;
            // 如果当前位置为0，则 son[p][1 - s] = son[p][1] 不为0，当前位置两节点都存在
            // 如果当前位置为1，则 son[p][1 - s] = son[p][0] 不为0，当前位置两节点都存在
            // 当前位置两节点都存在，才会将当前位置加入res
            if (son[p][1 - s] != 0) {
                // 计入res
                res += 1 << i;
                // 如果当前位置为0，则 son[p][1 - s] = son[p][1]
                // 如果当前位置为1，则 son[p][1 - s] = son[p][0]
                // 1111 1110 0111
                // 找到和当前位置值所在节点 相反位置节点的下一个节点
                p = son[p][1 - s];
            } else {
                // 如果当前位置为0，则son[p][s] = son[p][0]
                // 如果当前位置为1，则son[p][s] = son[p][1]
                // 当前位置值所在节点 相反位置节点不存在，遍历当前位置所在节点的下一个节点
                p = son[p][s];
            }
        }

        return res;
    }
    void print() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < 26; j++) {
                System.out.print(son[i][j] + " ");
            }
            System.out.println();
        }
    }
}